/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.smartandroid.sa.sherlock.internal.view.menu;

import java.util.ArrayList;

import android.content.Context;
import android.content.res.Resources;
import android.database.DataSetObserver;
import android.os.Parcelable;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.MeasureSpec;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.FrameLayout;
import android.widget.ListAdapter;
import android.widget.PopupWindow;

import com.smartandroid.sa.sherlock.internal.view.View_HasStateListenerSupport;
import com.smartandroid.sa.sherlock.internal.view.View_OnAttachStateChangeListener;
import com.smartandroid.sa.sherlock.internal.widget.IcsListPopupWindow;
import com.smartandroid.sa.sherlock.view.MenuItem;

/**
 * Presents a menu as a small, simple popup anchored to another view.
 * 
 * @hide
 */
public class MenuPopupHelper implements AdapterView.OnItemClickListener,
		View.OnKeyListener, ViewTreeObserver.OnGlobalLayoutListener,
		PopupWindow.OnDismissListener, View_OnAttachStateChangeListener,
		MenuPresenter {
	// UNUSED private static final String TAG = "MenuPopupHelper";
	private Context mContext;
	// static final int ITEM_LAYOUT = 0;
	// static final int ITEM_LAYOUT = R.layout.abs__popup_menu_item_layout;

	private LayoutInflater mInflater;
	private IcsListPopupWindow mPopup;
	private MenuBuilder mMenu;
	private int mPopupMaxWidth;
	private View mAnchorView;
	private boolean mOverflowOnly;
	private ViewTreeObserver mTreeObserver;

	private MenuAdapter mAdapter;

	private Callback mPresenterCallback;

	boolean mForceShowIcon;

	private ViewGroup mMeasureParent;

	public MenuPopupHelper(Context context, MenuBuilder menu) {
		this(context, menu, null, false);
	}

	public MenuPopupHelper(Context context, MenuBuilder menu, View anchorView) {
		this(context, menu, anchorView, false);
	}

	public MenuPopupHelper(Context context, MenuBuilder menu, View anchorView,
			boolean overflowOnly) {
		mContext = context;
		mInflater = LayoutInflater.from(context);
		mMenu = menu;
		mOverflowOnly = overflowOnly;

		final Resources res = context.getResources();
		mPopupMaxWidth = Math.max(
				res.getDisplayMetrics().widthPixels / 2,
				res.getDimensionPixelSize(context.getResources().getIdentifier(
						"abs__config_prefDialogWidth", "dimen",
						context.getPackageName())));
		// res.getDimensionPixelSize(R.dimen.abs__config_prefDialogWidth));

		mAnchorView = anchorView;

		menu.addMenuPresenter(this);
	}

	public void setAnchorView(View anchor) {
		mAnchorView = anchor;
	}

	public void setForceShowIcon(boolean forceShow) {
		mForceShowIcon = forceShow;
	}

	public void show() {
		if (!tryShow()) {
			throw new IllegalStateException(
					"MenuPopupHelper cannot be used without an anchor");
		}
	}

	public boolean tryShow() {
		mPopup = new IcsListPopupWindow(mContext, null, android.R.attr.popupMenuStyle);
		mPopup.setOnDismissListener(this);
		mPopup.setOnItemClickListener(this);

		mAdapter = new MenuAdapter(mMenu);
		mPopup.setAdapter(mAdapter);
		mPopup.setModal(true);

		View anchor = mAnchorView;
		if (anchor != null) {
			// Don't attach to the VTO unless the anchor itself is attached to
			// avoid VTO-related leaks.
			if (anchor.getWindowToken() != null) {
				ViewTreeObserver vto = anchor.getViewTreeObserver();
				if (vto != mTreeObserver) {
					if (mTreeObserver != null && mTreeObserver.isAlive()) {
						mTreeObserver.removeGlobalOnLayoutListener(this);
					}
					if ((mTreeObserver = vto) != null) {
						vto.addOnGlobalLayoutListener(this);
					}
				}
			} else if (anchor instanceof View_HasStateListenerSupport) {
				((View_HasStateListenerSupport) anchor)
						.addOnAttachStateChangeListener(this);
			}
			mPopup.setAnchorView(anchor);
		} else {
			return false;
		}

		mPopup.setContentWidth(Math.min(measureContentWidth(mAdapter),
				mPopupMaxWidth));
		mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED);
		mPopup.show();
		mPopup.getListView().setOnKeyListener(this);
		return true;
	}

	public void dismiss() {
		if (isShowing()) {
			mPopup.dismiss();
		}
	}

	public void onDismiss() {
		mPopup = null;
		mMenu.close();
		if (mTreeObserver != null) {
			if (mTreeObserver.isAlive())
				mTreeObserver.removeGlobalOnLayoutListener(this);
			mTreeObserver = null;
		} else if (mAnchorView instanceof View_HasStateListenerSupport) {
			((View_HasStateListenerSupport) mAnchorView)
					.removeOnAttachStateChangeListener(this);
		}
	}

	public boolean isShowing() {
		return mPopup != null && mPopup.isShowing();
	}

	@Override
	public void onItemClick(AdapterView<?> parent, View view, int position,
			long id) {
		MenuAdapter adapter = mAdapter;
		adapter.mAdapterMenu.performItemAction(adapter.getItem(position), 0);
	}

	public boolean onKey(View v, int keyCode, KeyEvent event) {
		if (event.getAction() == KeyEvent.ACTION_UP
				&& keyCode == KeyEvent.KEYCODE_MENU) {
			dismiss();
			return true;
		}
		return false;
	}

	private int measureContentWidth(ListAdapter adapter) {
		// Menus don't tend to be long, so this is more sane than it looks.
		int width = 0;
		View itemView = null;
		int itemType = 0;
		final int widthMeasureSpec = MeasureSpec.makeMeasureSpec(0,
				MeasureSpec.UNSPECIFIED);
		final int heightMeasureSpec = MeasureSpec.makeMeasureSpec(0,
				MeasureSpec.UNSPECIFIED);
		final int count = adapter.getCount();
		for (int i = 0; i < count; i++) {
			final int positionType = adapter.getItemViewType(i);
			if (positionType != itemType) {
				itemType = positionType;
				itemView = null;
			}
			if (mMeasureParent == null) {
				mMeasureParent = new FrameLayout(mContext);
			}
			itemView = adapter.getView(i, itemView, mMeasureParent);
			itemView.measure(widthMeasureSpec, heightMeasureSpec);
			width = Math.max(width, itemView.getMeasuredWidth());
		}
		return width;
	}

	@Override
	public void onGlobalLayout() {
		if (isShowing()) {
			final View anchor = mAnchorView;
			if (anchor == null || !anchor.isShown()) {
				dismiss();
			} else if (isShowing()) {
				// Recompute window size and position
				mPopup.show();
			}
		}
	}

	@Override
	public void onViewAttachedToWindow(View v) {
		((View_HasStateListenerSupport) v)
				.removeOnAttachStateChangeListener(this);

		// The anchor wasn't attached in tryShow(), attach to the ViewRoot VTO
		// now.
		if (mPopup != null && mTreeObserver == null) {
			(mTreeObserver = v.getViewTreeObserver())
					.addOnGlobalLayoutListener(this);
		}
	}

	@Override
	public void onViewDetachedFromWindow(View v) {
	}

	@Override
	public void initForMenu(Context context, MenuBuilder menu) {
		// Don't need to do anything; we added as a presenter in the
		// constructor.
	}

	@Override
	public MenuView getMenuView(ViewGroup root) {
		throw new UnsupportedOperationException(
				"MenuPopupHelpers manage their own views");
	}

	@Override
	public void updateMenuView(boolean cleared) {
		if (mAdapter != null)
			mAdapter.notifyDataSetChanged();
	}

	@Override
	public void setCallback(Callback cb) {
		mPresenterCallback = cb;
	}

	@Override
	public boolean onSubMenuSelected(SubMenuBuilder subMenu) {
		if (subMenu.hasVisibleItems()) {
			MenuPopupHelper subPopup = new MenuPopupHelper(mContext, subMenu,
					mAnchorView, false);
			subPopup.setCallback(mPresenterCallback);

			boolean preserveIconSpacing = false;
			final int count = subMenu.size();
			for (int i = 0; i < count; i++) {
				MenuItem childItem = subMenu.getItem(i);
				if (childItem.isVisible() && childItem.getIcon() != null) {
					preserveIconSpacing = true;
					break;
				}
			}
			subPopup.setForceShowIcon(preserveIconSpacing);

			if (subPopup.tryShow()) {
				if (mPresenterCallback != null) {
					mPresenterCallback.onOpenSubMenu(subMenu);
				}
				return true;
			}
		}
		return false;
	}

	@Override
	public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
		// Only care about the (sub)menu we're presenting.
		if (menu != mMenu)
			return;

		dismiss();
		if (mPresenterCallback != null) {
			mPresenterCallback.onCloseMenu(menu, allMenusAreClosing);
		}
	}

	@Override
	public boolean flagActionItems() {
		return false;
	}

	public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) {
		return false;
	}

	public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) {
		return false;
	}

	@Override
	public int getId() {
		return 0;
	}

	@Override
	public Parcelable onSaveInstanceState() {
		return null;
	}

	@Override
	public void onRestoreInstanceState(Parcelable state) {
	}

	private class MenuAdapter extends BaseAdapter {
		private MenuBuilder mAdapterMenu;
		private int mExpandedIndex = -1;

		public MenuAdapter(MenuBuilder menu) {
			mAdapterMenu = menu;
			registerDataSetObserver(new ExpandedIndexObserver());
			findExpandedIndex();
		}

		public int getCount() {
			ArrayList<MenuItemImpl> items = mOverflowOnly ? mAdapterMenu
					.getNonActionItems() : mAdapterMenu.getVisibleItems();
			if (mExpandedIndex < 0) {
				return items.size();
			}
			return items.size() - 1;
		}

		public MenuItemImpl getItem(int position) {
			ArrayList<MenuItemImpl> items = mOverflowOnly ? mAdapterMenu
					.getNonActionItems() : mAdapterMenu.getVisibleItems();
			if (mExpandedIndex >= 0 && position >= mExpandedIndex) {
				position++;
			}
			return items.get(position);
		}

		public long getItemId(int position) {
			// Since a menu item's ID is optional, we'll use the position as an
			// ID for the item in the AdapterView
			return position;
		}

		public View getView(int position, View convertView, ViewGroup parent) {
			if (convertView == null) {
				// R.layout.abs__popup_menu_item_layout;
				// ITEM_LAYOUT = mContext.getResources().getIdentifier(
				// "abs__popup_menu_item_layout", "layout",
				// mContext.getPackageName());
				convertView = mInflater.inflate(
						mContext.getResources().getIdentifier(
								"abs__popup_menu_item_layout", "layout",
								mContext.getPackageName()), parent, false);
			}

			MenuView.ItemView itemView = (MenuView.ItemView) convertView;
			if (mForceShowIcon) {
				((ListMenuItemView) convertView).setForceShowIcon(true);
			}
			itemView.initialize(getItem(position), 0);
			return convertView;
		}

		void findExpandedIndex() {
			final MenuItemImpl expandedItem = mMenu.getExpandedItem();
			if (expandedItem != null) {
				final ArrayList<MenuItemImpl> items = mMenu.getNonActionItems();
				final int count = items.size();
				for (int i = 0; i < count; i++) {
					final MenuItemImpl item = items.get(i);
					if (item == expandedItem) {
						mExpandedIndex = i;
						return;
					}
				}
			}
			mExpandedIndex = -1;
		}
	}

	private class ExpandedIndexObserver extends DataSetObserver {
		@Override
		public void onChanged() {
			mAdapter.findExpandedIndex();
		}
	}
}
